package cn.rkylin.oms.warehouse.extAdjust.service;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.github.pagehelper.PageInfo;

import cn.rkylin.apollo.common.util.SnoGerUtil;
import cn.rkylin.core.service.ApolloService;
import cn.rkylin.oms.common.consts.YesNoConst;
import cn.rkylin.oms.common.utils.CodeUtil;
import cn.rkylin.oms.goods.dao.IGoodsDAO;
import cn.rkylin.oms.goods.vo.GoodsSkuVO;
import cn.rkylin.oms.goodscost.dao.IGoodsCostDAO;
import cn.rkylin.oms.goodscost.vo.GoodsCostVO;
import cn.rkylin.oms.system.storage.dao.IStorDAO;
import cn.rkylin.oms.system.storage.domain.Stor;
import cn.rkylin.oms.warehouse.extAdjust.dao.IAdjustDAO;
import cn.rkylin.oms.warehouse.extAdjust.dao.IAdjustSkuDAO;
import cn.rkylin.oms.warehouse.extAdjust.vo.AdjustInfo;
import cn.rkylin.oms.warehouse.extAdjust.vo.AdjustSkuExportVO;
import cn.rkylin.oms.warehouse.extAdjust.vo.AdjustSkuVO;
import cn.rkylin.oms.warehouse.extAdjust.vo.AdjustVO;
import cn.rkylin.oms.warehouse.stock.dao.IStockDAO;
import cn.rkylin.oms.warehouse.stock.service.IStockService;
import cn.rkylin.oms.warehouse.stock.vo.StockVO;

/**
 * Created by Administrator on 2018-4-16.
 */
@Service("adjustSkuService")
public class AdjustSkuService extends ApolloService {
    private static final Log logger = LogFactory.getLog(AdjustSkuService.class);

    @Autowired
    private IStockDAO stockDAO;

    @Autowired
    private IStorDAO storDAO;

    @Autowired
    private IAdjustDAO adjustDAO;

    @Autowired
    private IAdjustSkuDAO adjustSkuDAO;
    
    /**
     * 批量废弃调整单
     * 
     * @param adjustIds 批量调整单Id
     * @return 更新的数量
     * @throws Exception 异常
     */
	public int batchCancelAdjust(String[] adjustIds) throws Exception {
		int updatedCount = 0;
		
		for (int i = 0; i < adjustIds.length; i++) {
			AdjustVO adjustVO = new AdjustVO();
			adjustVO.setAdjustId(adjustIds[i]);
			adjustVO.setIsCancel(YesNoConst.YES);
			updatedCount = updatedCount + adjustDAO.update(adjustVO);
		}
		
		return updatedCount;
	}

    @Autowired
    private IStockService stockService;

    @Autowired
    private IGoodsCostDAO goodsCostDAO;

    @Autowired
    private IGoodsDAO goodsDAO;

    public List<AdjustVO> findCounts(AdjustVO vo) throws Exception {
        List<AdjustVO> list = findPage("selectAdjustCounts", vo);
        return list;
    }

    public PageInfo<AdjustVO> findByWhere(int page, int rows, AdjustVO vo) throws Exception {
        logger.error("【订单查询条件.prjId】-->" + vo.getPrjId());
        logger.error("【订单查询条件.storId】-->" + vo.getStorId());
        PageInfo<AdjustVO> list = findPage(page, rows, "pageSelectAdjust", vo);
        return list;
    }

    /**
     * 创建新的调整单，修改调整单
     * @param adjustInfo
     * @return
     * @throws Exception
     */
    public Map<String, Object> modifyAdjustData(AdjustInfo adjustInfo) throws Exception{
        Map<String, Object> result = new HashMap<String, Object>();
        if (adjustInfo == null){
            result.put("result", "failed");
            result.put("msg", "要操作的数据是空");
            return result;
        }

        if (adjustInfo.getAdjustSku()==null || adjustInfo.getAdjustSku().size()<=0){
            result.put("result", "failed");
            result.put("msg", "要操作的数据是空");
            return result;
        }

        Stor stor = storDAO.findByid(adjustInfo.getStorId());
        if (stor==null){
            result.put("result", "failed");
            result.put("msg", "仓库不存在");
            return result;
        }

        if (!"ext".equals(stor.getStorType())){
            result.put("result", "failed");
            result.put("msg", "仓库不是第三方仓库");
            return result;
        }

        Map<String , String> checkList =  new HashMap<String,String>();
        for (int i = 0 ; i < adjustInfo.getAdjustSku().size() ; i++){
            String key = adjustInfo.getAdjustSku().get(i).getSkuCode() + ":" + adjustInfo.getAdjustSku().get(i).getStockType() + ":" + adjustInfo.getAdjustSku().get(i).getBatchCode() + ":" + adjustInfo.getAdjustSku().get(i).getProductDate();
            if (checkList.get(key)!=null){
                result.put("result", "failed");
                result.put("msg", "规格商家编码："+adjustInfo.getAdjustSku().get(i).getSkuCode()+" 库存类型：" + adjustInfo.getAdjustSku().get(i).getStockType()+ " 批次：" + adjustInfo.getAdjustSku().get(i).getBatchCode() + "效期：" +adjustInfo.getAdjustSku().get(i).getProductDate() + "有重复数据");
                return result;
            } else {
                if ("n".equals(adjustInfo.getAdjustSku().get(i).getDeleted())){
                    checkList.put(key,key);
                }
            }

            //取得oms_goods_sku 取得skuID googsId 成本价
            GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
            goodsSkuVO.setSkuCode(adjustInfo.getAdjustSku().get(i).getSkuCode());
            goodsSkuVO.setPrjId(adjustInfo.getPrjId());
            List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCode", goodsSkuVO);
            if (goodsSkuVOList==null || goodsSkuVOList.size()<=0){
                result.put("result", "failed");
                result.put("msg", "规格商家编码："+adjustInfo.getAdjustSku().get(i).getSkuCode()+"在本项目下，没有商品SKU数据");
                return result;
            } else{
                adjustInfo.getAdjustSku().get(i).setGoodsSkuCost(goodsSkuVOList.get(0).getCostPrice());
                adjustInfo.getAdjustSku().get(i).setGoodsId(goodsSkuVOList.get(0).getGoodsId());
                adjustInfo.getAdjustSku().get(i).setGoodsName(goodsSkuVOList.get(0).getGoodsName());
                adjustInfo.getAdjustSku().get(i).setSkuId(goodsSkuVOList.get(0).getSkuId());
                adjustInfo.getAdjustSku().get(i).setSkuName(goodsSkuVOList.get(0).getSkuName());
            }

            //判断是带有批次，效期 还是不带
            if (StringUtils.isBlank(adjustInfo.getAdjustSku().get(i).getBatchCode())){
                //业务check oms_sku_stock
                StockVO param = new StockVO();
                param.setEntId(adjustInfo.getEntId());
                param.setSkuId(adjustInfo.getAdjustSku().get(i).getSkuId());
                param.setStorId(adjustInfo.getStorId());
                StockVO stockVO = stockDAO.getStock(param);
                if (stockVO==null){
                    result.put("result", "failed");
                    result.put("msg", "规格商家编码："+adjustInfo.getAdjustSku().get(i).getSkuCode()+"在当前仓库下，没有库存数据");
                    return result;
                }

                if ("正品".equals(adjustInfo.getAdjustSku().get(i).getStockType())){
                    if (stockVO.getStockQty().intValue()+adjustInfo.getAdjustSku().get(i).getQty().intValue()<0){
                        result.put("result", "failed");
                        result.put("msg", "规格商家编码："+adjustInfo.getAdjustSku().get(i).getSkuCode()+"在当前仓库下，调整后正品库存为负数");
                        return result;
                    }
                } else {
                    if (stockVO.getJunkQty().intValue()+adjustInfo.getAdjustSku().get(i).getQty().intValue()<0){
                        result.put("result", "failed");
                        result.put("msg", "规格商家编码："+adjustInfo.getAdjustSku().get(i).getSkuCode()+"在当前仓库下，调整后次品库存为负数");
                        return result;
                    }
                }
            } else {
                //批次，效期 场合下的处理 TODO

            }

        }

        //生成调整单
        if (StringUtils.isBlank(adjustInfo.getAdjustId())){ //insert
            String adjustId = java.util.UUID.randomUUID().toString().replaceAll("-", "");
            AdjustVO adjustVO = new AdjustVO();
            adjustVO.setAdjustId(adjustId);
            adjustVO.setAdjustCode("AD"+adjustInfo.getPrjShortName() + CodeUtil.getCode());
            adjustVO.setEntId(adjustInfo.getEntId());
            adjustVO.setPrjId(adjustInfo.getPrjId());
            adjustVO.setCreateTime(new Date());
            adjustVO.setUpdateTime(new Date());
            adjustVO.setDeleted("n");
            adjustVO.setStorId(adjustInfo.getStorId());
            adjustVO.setStorCode(stor.getStorCode());
            adjustVO.setStorName(stor.getStorName());
            adjustVO.setAdjustType("sd");
            adjustVO.setCreateUser(adjustInfo.getCreateUser());
            adjustVO.setIsCancel("n");
            adjustVO.setRemark(adjustInfo.getRemark());
            adjustDAO.insert(adjustVO);

            for (int i = 0 ; i < adjustInfo.getAdjustSku().size() ; i++){
                AdjustSkuVO adjustSkuVO = new AdjustSkuVO();
                adjustSkuVO.setAdjustSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                adjustSkuVO.setAdjustId(adjustId);
                adjustSkuVO.setUpdateTime(new Date());
                adjustSkuVO.setCreateTime(new Date());
                adjustSkuVO.setDeleted("n");
                adjustSkuVO.setSkuId(adjustInfo.getAdjustSku().get(i).getSkuId());
                adjustSkuVO.setSkuCode(adjustInfo.getAdjustSku().get(i).getSkuCode());
                adjustSkuVO.setSkuName(adjustInfo.getAdjustSku().get(i).getSkuName());
                adjustSkuVO.setGoodsId(adjustInfo.getAdjustSku().get(i).getGoodsId());
                adjustSkuVO.setGoodsCode(adjustInfo.getAdjustSku().get(i).getGoodsCode());
                adjustSkuVO.setGoodsName(adjustInfo.getAdjustSku().get(i).getGoodsName());
                adjustSkuVO.setQty(adjustInfo.getAdjustSku().get(i).getQty());
                if ("正品".equals(adjustInfo.getAdjustSku().get(i).getStockType())){
                    adjustSkuVO.setStockType("zp");
                } else {
                    adjustSkuVO.setStockType("cp");
                }
                adjustSkuVO.setGoodsSkuCost(adjustInfo.getAdjustSku().get(i).getGoodsSkuCost());
                adjustSkuVO.setRemark(adjustInfo.getAdjustSku().get(i).getRemark());
                adjustSkuVO.setBatchCode(adjustInfo.getAdjustSku().get(i).getBatchCode());
                adjustSkuVO.setProductDate(adjustInfo.getAdjustSku().get(i).getProductDate());
                adjustSkuVO.setDataType(adjustInfo.getAdjustSku().get(i).getDataType());
                adjustSkuDAO.insert(adjustSkuVO);
            }

        } else { //修改
            AdjustVO adjustVO = new AdjustVO();
            adjustVO.setAdjustId(adjustInfo.getAdjustId());
            adjustVO.setUpdateTime(new Date());
            adjustVO.setStorId(adjustInfo.getStorId());
            adjustVO.setStorCode(stor.getStorCode());
            adjustVO.setStorName(stor.getStorName());
            adjustVO.setRemark(adjustInfo.getRemark());
            adjustDAO.update(adjustVO);

            for (int i = 0 ; i < adjustInfo.getAdjustSku().size() ; i++){
                if ("update".equals(adjustInfo.getAdjustSku().get(i).getAction())){
                    AdjustSkuVO adjustSkuVO = new AdjustSkuVO();
                    adjustSkuVO.setUpdateTime(new Date());
                    adjustSkuVO.setDeleted(adjustInfo.getAdjustSku().get(i).getDeleted());
                    adjustSkuVO.setQty(adjustInfo.getAdjustSku().get(i).getQty());
                    if ("正品".equals(adjustInfo.getAdjustSku().get(i).getStockType())){
                        adjustSkuVO.setStockType("zp");
                    } else {
                        adjustSkuVO.setStockType("cp");
                    }
                    adjustSkuVO.setRemark(adjustInfo.getAdjustSku().get(i).getRemark());
                    adjustSkuVO.setAdjustSkuId(adjustInfo.getAdjustSku().get(i).getAdjustSkuId());
                    adjustSkuDAO.update(adjustSkuVO);
                } else {
                    AdjustSkuVO adjustSkuVO = new AdjustSkuVO();
                    adjustSkuVO.setAdjustSkuId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                    adjustSkuVO.setAdjustId(adjustInfo.getAdjustId());
                    adjustSkuVO.setUpdateTime(new Date());
                    adjustSkuVO.setCreateTime(new Date());
                    adjustSkuVO.setDeleted("n");
                    adjustSkuVO.setSkuId(adjustInfo.getAdjustSku().get(i).getSkuId());
                    adjustSkuVO.setSkuCode(adjustInfo.getAdjustSku().get(i).getSkuCode());
                    adjustSkuVO.setSkuName(adjustInfo.getAdjustSku().get(i).getSkuName());
                    adjustSkuVO.setGoodsId(adjustInfo.getAdjustSku().get(i).getGoodsId());
                    adjustSkuVO.setGoodsCode(adjustInfo.getAdjustSku().get(i).getGoodsCode());
                    adjustSkuVO.setGoodsName(adjustInfo.getAdjustSku().get(i).getGoodsName());
                    adjustSkuVO.setQty(adjustInfo.getAdjustSku().get(i).getQty());
                    if ("正品".equals(adjustInfo.getAdjustSku().get(i).getStockType())){
                        adjustSkuVO.setStockType("zp");
                    } else {
                        adjustSkuVO.setStockType("cp");
                    }
                    adjustSkuVO.setGoodsSkuCost(adjustInfo.getAdjustSku().get(i).getGoodsSkuCost());
                    adjustSkuVO.setRemark(adjustInfo.getAdjustSku().get(i).getRemark());
                    adjustSkuVO.setBatchCode(adjustInfo.getAdjustSku().get(i).getBatchCode());
                    adjustSkuVO.setProductDate(adjustInfo.getAdjustSku().get(i).getProductDate());
                    adjustSkuVO.setDataType(adjustInfo.getAdjustSku().get(i).getDataType());
                    adjustSkuDAO.insert(adjustSkuVO);
                }
            }
        }

        result.put("result", "success");
        result.put("msg", "数据处理成功");
        return result;
    }

    /**
     * OrderSku的取得
     */
    public List<AdjustSkuVO> getAdjustSku(AdjustSkuVO adjustSkuVO) throws Exception {
        if (adjustSkuVO == null) {
            return null;
        }
        return adjustSkuDAO.getAdjustSkuAll(adjustSkuVO);
    }

    /**
     * OrderSku的取得
     */
    public List<AdjustSkuVO> showAdjustSku(AdjustSkuVO adjustSkuVO) throws Exception {
        if (adjustSkuVO == null) {
            return null;
        }
        return adjustSkuDAO.getAdjustSku(adjustSkuVO);
    }

    /**
     * 调整库存
     *
     * @param adjustId 系统订单id
     */
    public Map<String, Object> updateAdjust(String adjustId,String account) throws Exception {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        if (StringUtils.isNotBlank(adjustId)) {
            //调整单取得
            AdjustVO adjustVO = adjustDAO.findById(adjustId);
            if (adjustVO==null){
                returnMap.put("result", "failed");
                returnMap.put("msg", "调整单没有相关数据");
                return returnMap;
            }

            AdjustSkuVO adjustSkuVO = new AdjustSkuVO();
            adjustSkuVO.setAdjustId(adjustId);
            List<AdjustSkuVO> listAdjustSku = adjustSkuDAO.getAdjustSku(adjustSkuVO);
            if (listAdjustSku==null || listAdjustSku.size()<=0){
                returnMap.put("result", "failed");
                returnMap.put("msg", "没有要调整的SKU");
                return returnMap;
            }

            //非批次
            Map<String , List<AdjustSkuVO>> mapAdjustSkuVO = new HashMap<String , List<AdjustSkuVO>>();
//            Map<String , StockVO> mapStockVO = new HashMap<String , StockVO>();

            //批次
//            Map<String , List<AdjustSkuVO>> mapAdjustSkuVOb = new HashMap<String , List<AdjustSkuVO>>();
            for (int i = 0 ; i < listAdjustSku.size() ; i++){
                //取得oms_goods_sku 取得skuID googsId 成本价
                GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
                goodsSkuVO.setSkuCode(listAdjustSku.get(i).getSkuCode());
                goodsSkuVO.setPrjId(adjustVO.getPrjId());
                List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCode", goodsSkuVO);
                if (goodsSkuVOList==null || goodsSkuVOList.size()<=0){
                    returnMap.put("result", "failed");
                    returnMap.put("msg", "规格商家编码："+listAdjustSku.get(i).getSkuCode()+"在本项目下，没有商品SKU数据");
                    return returnMap;
                }

                //判断是带有批次，效期 还是不带
                if (StringUtils.isBlank(listAdjustSku.get(i).getBatchCode())){
                    //业务check oms_sku_stock
                    StockVO param = new StockVO();
                    param.setEntId(adjustVO.getEntId());
                    param.setSkuId(listAdjustSku.get(i).getSkuId());
                    param.setStorId(adjustVO.getStorId());
                    StockVO stockVO = stockDAO.getStock(param);
                    if (stockVO==null){
                        returnMap.put("result", "failed");
                        returnMap.put("msg", "规格商家编码："+listAdjustSku.get(i).getSkuCode()+"在当前仓库下，没有库存数据");
                        return returnMap;
                    }

                    if ("zp".equals(listAdjustSku.get(i).getStockType())){
                        if (stockVO.getStockQty().intValue()+listAdjustSku.get(i).getQty().intValue()<0){
                            returnMap.put("result", "failed");
                            returnMap.put("msg", "规格商家编码："+listAdjustSku.get(i).getSkuCode()+"在当前仓库下，调整后正品库存为负数");
                            return returnMap;
                        }
                    } else {
                        if (stockVO.getJunkQty().intValue()+listAdjustSku.get(i).getQty().intValue()<0){
                            returnMap.put("result", "failed");
                            returnMap.put("msg", "规格商家编码："+listAdjustSku.get(i).getSkuCode()+"在当前仓库下，调整后次品库存为负数");
                            return returnMap;
                        }
                    }
//                    mapStockVO.put(adjustVO.getEntId()+":"+listAdjustSku.get(i).getSkuId()+":"+adjustVO.getStorId(),stockVO);
                    List<AdjustSkuVO> list = new ArrayList<AdjustSkuVO>();
                    if (mapAdjustSkuVO.get(adjustVO.getEntId()+":"+listAdjustSku.get(i).getSkuId()+":"+adjustVO.getStorId())!=null){
                        list = mapAdjustSkuVO.get(adjustVO.getEntId()+":"+listAdjustSku.get(i).getSkuId()+":"+adjustVO.getStorId());
                    }
                    list.add(listAdjustSku.get(i));
                    mapAdjustSkuVO.put(adjustVO.getEntId()+":"+listAdjustSku.get(i).getSkuId()+":"+adjustVO.getStorId(),list);
                } else {
                    //批次，效期 场合下的处理 TODO

                }

            }

            //非批次的处理
            for (Map.Entry<String, List<AdjustSkuVO>> entry : mapAdjustSkuVO.entrySet()) {
                String adjustVOKey =  entry.getKey();
                List<AdjustSkuVO> list = entry.getValue();
                for (int i = 0 ; i < list.size() ; i++){
                    //据说要用最新的价格来进行加权计算，原有的价格相当于没用。奥卡西
                    GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
                    goodsSkuVO.setSkuCode(list.get(i).getSkuCode());
                    goodsSkuVO.setPrjId(adjustVO.getPrjId());
                    List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCode", goodsSkuVO);
                    list.get(i).setGoodsSkuCost(goodsSkuVOList.get(0).getCostPrice());
                    // 更新库存
                    StockVO skuStockUpdate = new StockVO();
                    skuStockUpdate.setEntId(adjustVO.getEntId());
                    skuStockUpdate.setStorId(adjustVO.getStorId());
                    skuStockUpdate.setSkuId(list.get(0).getSkuId());
                    skuStockUpdate.setSourceCode(adjustVO.getSourceCode());
                    skuStockUpdate.setTag("调整单调整");
                    int junkQty = 0;
                    int stockQty = 0;
                    if ("zp".equals(list.get(i).getStockType())){
                        stockQty=stockQty+ list.get(i).getQty();
                    } else {
                        junkQty=junkQty+list.get(i).getQty();
                    }
                    skuStockUpdate.setJunkQty(junkQty);
                    skuStockUpdate.setStockQty(stockQty);
                    int iStockRes = stockService.updateStock(skuStockUpdate);
                    if (iStockRes <= 0) {
                        returnMap.put("result", "failed");
                        returnMap.put("msg", "更新库存失败");
                    }

                    // 计算移动加权
                    // 获取入库类型信息，是否需要移动加权计算
                    //调增（则按照新增单据时保存的成本价及数量信息进行移动加权计算，计算后的成本记录到成本管理中，但不更新单据上的成本价）调减（不进行移动加权计算，取调整成功时的商品SKU即时成本价）
                    if (junkQty+stockQty>0){
                        GoodsCostVO goodsCostTemp = new GoodsCostVO();
                        goodsCostTemp.setSkuId(list.get(0).getSkuId()); //skuid
                        goodsCostTemp.setQty(junkQty+stockQty); //实际入库数量
                        goodsCostTemp.setSourceId(adjustVO.getAdjustId()); //来源单据ID
                        goodsCostTemp.setSourceCode(adjustVO.getAdjustCode()); //来源单据编码
                        goodsCostTemp.setEntId(adjustVO.getEntId()); //企业ID
                        goodsCostTemp.setOperType("调整单"); //操作类型
                        goodsCostTemp.setRemark("调整单库存调整");
                        goodsCostTemp.setOrigCost(list.get(i).getGoodsSkuCost());

                        //调用 移动加权成本价计算 函数，实现系统规格商品成本价加权计算
                        Map<String,Object> res = DoGoodsCostComputer(goodsCostTemp,account);
                    }

                    StockVO param = new StockVO();
                    param.setEntId(adjustVO.getEntId());
                    param.setSkuId(listAdjustSku.get(i).getSkuId());
                    param.setStorId(adjustVO.getStorId());
                    StockVO stockVO = stockDAO.getStock(param);

                    AdjustSkuVO adjustSkuVOForUpdate = list.get(i);
                    adjustSkuVOForUpdate.setUpdateTime(new Date());
//                    adjustSkuVOForUpdate.setGoodsSkuCost(stockVO.getGoodsSkuCost());
                    if ("zp".equals(adjustSkuVOForUpdate.getStockType())){
                        adjustSkuVOForUpdate.setStockQty(stockVO.getStockQty());
                    } else {
                        adjustSkuVOForUpdate.setStockQty(stockVO.getJunkQty());
                    }
                    adjustSkuDAO.update(adjustSkuVOForUpdate);

                }

                AdjustVO adjustVOUp = new AdjustVO();
                adjustVOUp.setAdjustStatus("y");
                adjustVOUp.setAdjustId(list.get(0).getAdjustId());
                adjustVOUp.setUpdateTime(new Date());
                adjustVOUp.setAdjustTime(new Date());
                adjustDAO.update(adjustVOUp);
            }

            //批次处理 TODO

            returnMap.put("result", "success");
            returnMap.put("msg", "");
            return returnMap;

        } else {
            returnMap.put("result", "failed");
            returnMap.put("msg", "请选择要调整的单据");
            return returnMap;
        }
    }

    /**
     * 商品成本移动加权计算 wangxing add
     * 公式：( (期初库存 * 即时成本价)  +  (当前单据实际入库数 * 单据成本价 或 采购单价)  )  /  (期初库存 + 当前单据实际入库数)
     *
     * @param parmGoodsCost
     * @return
     * @throws Exception
     */
    public Map<String,Object> DoGoodsCostComputer(GoodsCostVO parmGoodsCost,String account) throws Exception {
        Map<String,Object> res = new HashMap<String,Object>() ;
        int iRes = 0;
        //期初库存数
        int iBeginStockQty = 0;
        //期初成本价
        BigDecimal bdBeginCost = BigDecimal.ZERO;
        //当前单据成本价
        BigDecimal bdNowCost = BigDecimal.ZERO;
        //计算后的成本价
        BigDecimal bdLastCost = BigDecimal.ZERO;

        //获取当前系统规格库存数相关信息
        StockVO skuStockVO = new StockVO();
        skuStockVO.setSkuId(parmGoodsCost.getSkuId());
        skuStockVO.setEntId(parmGoodsCost.getEntId());
        StockVO skuStockVORes = stockDAO.selectSkuStockBySkuId(skuStockVO);

        if (skuStockVORes != null) {
//1、计算移动加权成本价-------------------------------------------------------------------------------------
            //商品即时成本价
            BigDecimal bdGoodsSkuCost = skuStockVORes.getGoodsSkuCost();
            //总库存数加上实际入库数大于0
            if ((skuStockVORes.getStockQty() + skuStockVORes.getJunkQty()) > 0) {
                //如果 即时成本价为0，则当前移动加权成本价为当前单据上的成本价 或 采购单价
                if (bdGoodsSkuCost == BigDecimal.ZERO) {
                    bdLastCost = parmGoodsCost.getOrigCost();
                } else {
                    //当前商品即时成本价非0，计算成移动加权成本价

                    //期初库存数
                    iBeginStockQty = skuStockVORes.getStockQty() + skuStockVORes.getJunkQty() - parmGoodsCost.getQty();
                    //期初成本价 = 期初库存数 * 即时成本价
                    bdBeginCost = bdGoodsSkuCost.multiply(BigDecimal.valueOf(iBeginStockQty));
                    //当前单据成本价 = 实际入库数 * 单据成本价(或采购单价)
                    bdNowCost = parmGoodsCost.getOrigCost().multiply(BigDecimal.valueOf(parmGoodsCost.getQty()));
                    //计算后成本价 = (期初成本价 + 当前单据成本价)  /  (期初库存数 + 实际入库数)
                    bdLastCost = bdNowCost.add(bdBeginCost);
                    bdLastCost = bdLastCost.divide(BigDecimal.valueOf(skuStockVORes.getStockQty() + skuStockVORes.getJunkQty()), 2, BigDecimal.ROUND_HALF_UP);
                }
            } else {
                //总库存数加上实际入库数小于等于0，加权平均值取商品规格原成本
                bdLastCost = bdGoodsSkuCost;
            }
//2、将结果插入到商品成本管理表中 oms_goods_cost------------------------------------------------------------
            GoodsCostVO goodsCost = new GoodsCostVO();
            goodsCost.setGoodsCostId(SnoGerUtil.getUUID());
            goodsCost.setEntId(skuStockVORes.getEntId());
            goodsCost.setSkuId(skuStockVORes.getSkuId());
            goodsCost.setSkuCode(skuStockVORes.getSkuCode());
            goodsCost.setSkuName(skuStockVORes.getSkuName());
            goodsCost.setGoodsId(skuStockVORes.getGoodsId());
            goodsCost.setGoodsCode(skuStockVORes.getGoodsCode());
            goodsCost.setGoodsName(skuStockVORes.getGoodsName());
            goodsCost.setOrigCost(bdGoodsSkuCost);
            goodsCost.setCurtCost(bdLastCost);
            goodsCost.setOperTime(new Date());
            goodsCost.setOperType(parmGoodsCost.getOperType());
            goodsCost.setOperMode("手动");
            goodsCost.setOperUserName(account);
            goodsCost.setSourceId(parmGoodsCost.getSourceId());
            goodsCost.setSourceCode(parmGoodsCost.getSourceCode());
            //总库存数加上实际入库数大于0
            if ((skuStockVORes.getStockQty() + skuStockVORes.getJunkQty()) > 0) {
                String strFormula = "(" + String.valueOf(iBeginStockQty) + "*" + String.valueOf(bdGoodsSkuCost)
                        + "+" + String.valueOf(parmGoodsCost.getQty()) + "*" + String.valueOf(parmGoodsCost.getOrigCost())
                        + ")/(" + String.valueOf(iBeginStockQty) + "+" + String.valueOf(parmGoodsCost.getQty()) + ")";
                goodsCost.setRemark(strFormula);
            } else {
                goodsCost.setRemark(parmGoodsCost.getRemark());
            }
            int iInsert = goodsCostDAO.insertGoodsCostChanger(goodsCost);
            if (iInsert > 0) {
//3、更新系统规格成本价为当前计算结果-----------------------------------------------------------------------
                GoodsSkuVO sysGoodsSku = new GoodsSkuVO();
                sysGoodsSku.setSkuId(skuStockVORes.getSkuId());
                sysGoodsSku.setCostPrice(bdLastCost);
                sysGoodsSku.setUpdateTime(new Date());
                int iUpdate = goodsDAO.updateGoodsSkuCostBySkuId(sysGoodsSku);
            }
            iRes = iInsert;
        }
        res.put("iRes",iRes);
        res.put("bdLastCost",bdLastCost);
        return res;
    }

    public List<AdjustSkuExportVO> exportSku(Map map) throws Exception {
        if (map == null) {
            return null;
        }
        // OrderSkuVO vo = new OrderSkuVO();
        // vo.setOrderId(orderId);
        return adjustSkuDAO.exportSku(map);
    }

    private boolean checkValue(String regex , String value){
//        String regex="^[a-zA-Z0-9]+$";
        Pattern pattern = Pattern.compile(regex);
        Matcher match = pattern.matcher(value);
        return(match.matches());
    }
    public Map<String , Object> importCheck(Map<String,String> mapParm) throws Exception {

        String regex="^[a-zA-Z0-9]+$"; //英文数字
        String regexNum= "^-?\\d+$"; //数字
        SimpleDateFormat s =  new SimpleDateFormat("yyyy-MM-dd");

        String json = mapParm.get("json");
        String storId = mapParm.get("storId");
        String mapAdjustSku = mapParm.get("mapAdjustSku");

        Map<String, Object> returnMap = new HashMap<String, Object>();
        if (StringUtils.isBlank(json)){
            returnMap.put("result", "failed");
            returnMap.put("msg", "没有要导入的数据");
            return returnMap;
        }
        if (StringUtils.isBlank(storId)){
            returnMap.put("result", "failed");
            returnMap.put("msg", "请选择仓库");
            return returnMap;
        }

        Map<String, String> mapTable = StringUtils.isBlank(mapAdjustSku)?new HashMap<String, String>():JSONObject.parseObject(mapAdjustSku,new TypeReference<Map<String, String>>() {
        });
        List<String> list = JSONArray.parseArray(json,String.class);
        List<AdjustSkuVO> listAdjustSkuVO= new ArrayList<AdjustSkuVO>(); //页面显示用
        List<Map<String,String>> listError = new ArrayList<Map<String,String>>();
        Map<String , String> mapCheckSame = new HashMap<String,String>();
        boolean flg = true;
        if (list==null || list.size()<=0){
            returnMap.put("result", "failed");
            returnMap.put("msg", "没有要导入的数据");
            return returnMap;
        }

        for (int i = 0 ; i < list.size() ; i++){
            Map<String,String> mapError = new HashMap<String,String>();
            String errorMsg = "";
            Map<String, String> map = JSONObject.parseObject(list.get(i),new TypeReference<Map<String, String>>() {
            });
            String skuCode = map.get("规格商家编码");
            String stockType = map.get("库存类型");
            String qty = map.get("调整数");
            String batchCode = StringUtils.isBlank(map.get("批次编号"))?"":map.get("批次编号");
            String productDate = StringUtils.isBlank(map.get("生产日期"))?"":map.get("生产日期");
            String remark = map.get("备注");

            if (mapTable.get(skuCode+"-"+stockType+"-"+batchCode+"-"+productDate)!=null){
                errorMsg = errorMsg + " 数据重复";
            }
            if (StringUtils.isBlank(skuCode)){
                errorMsg = errorMsg + " 规格商家编码:不能为空";
            } else {
                if(skuCode.length()>100){
                    errorMsg = errorMsg + " 规格商家编码:长度超过100位";
                }
            }

            if (StringUtils.isBlank(stockType)){
                errorMsg = errorMsg + " 库存类型:不能为空";
            } else {
                if((!"正品".equals(stockType.trim())) && (!"次品".equals(stockType.trim()))){
                    errorMsg = errorMsg + " 库存类型:只能输入（正品/次品）";
                }
            }

            if (StringUtils.isBlank(qty)){
                errorMsg = errorMsg + " 调整数:不能为空";
            } else {
                if (!checkValue(regexNum,qty)){
                    errorMsg = errorMsg + " 调整数:请输入整数字";
                } else {
                    if ("0".equals(qty)){
                        errorMsg = errorMsg + " 调整数:请输入非零整数字";
                    }
                }

            }

            if (StringUtils.isNotBlank(batchCode)){
                if(skuCode.length()>50){
                    errorMsg = errorMsg + " 批次编号:长度超过50位";
                }
            }

            if (StringUtils.isNotBlank(productDate)){
                try{
                    s.parse(productDate);
                } catch (Exception e){
                    errorMsg = errorMsg + " 生产日期:日期格式请按照YYYY-MM-DD格式输入";
                }
            }

            if (StringUtils.isNotBlank(remark)){
                if(skuCode.length()>255){
                    errorMsg = errorMsg + " 备注:长度超过255位";
                }
            }

            if (StringUtils.isBlank(errorMsg)){
                String checkKey = skuCode+":"+stockType+":"+batchCode+":"+productDate;
                if (mapCheckSame.get(checkKey)==null){
                    mapCheckSame.put(checkKey,checkKey);
                } else {
                    errorMsg = errorMsg + " 规格商家编码："+skuCode+"有重复数据";
                }
            }

            if (StringUtils.isBlank(errorMsg)){
                AdjustSkuVO vo = new AdjustSkuVO();

                //取得oms_goods_sku 取得skuID googsId 成本价
                GoodsSkuVO goodsSkuVO = new GoodsSkuVO();
                goodsSkuVO.setSkuCode(skuCode);
                goodsSkuVO.setPrjId(mapParm.get("prjId"));
                List<GoodsSkuVO> goodsSkuVOList = findPage("selectGoodsSkuListBySkuCode", goodsSkuVO);
                String skuId = "";
                String goodsCode = "";
                String goodsName = "";
                String skuName = "";
                if (goodsSkuVOList==null || goodsSkuVOList.size()<=0){
                    errorMsg = errorMsg + " 规格商家编码："+skuCode+"在本项目下，没有商品SKU数据";
                } else {
                    goodsCode = goodsSkuVOList.get(0).getGoodsCode();
                    skuId = goodsSkuVOList.get(0).getSkuId();
                    goodsName = goodsSkuVOList.get(0).getGoodsName();
                    skuName = goodsSkuVOList.get(0).getSkuName();

                    //判断是带有批次，效期 还是不带
                    if (StringUtils.isBlank(batchCode)){
                        //业务check oms_sku_stock
                        StockVO param = new StockVO();
                        param.setEntId(mapParm.get("entId"));
                        param.setSkuId(skuId);
                        param.setStorId(storId);
                        StockVO stockVO = stockDAO.getStock(param);
                        if (stockVO==null){
                            errorMsg = errorMsg + " 规格商家编码："+skuCode+"在当前仓库下，没有库存数据";
                        } else {
                            if ("正品".equals(stockType)){
                                if (stockVO.getStockQty().intValue()+Integer.parseInt(qty)<0){
                                    errorMsg = errorMsg + " 规格商家编码："+skuCode+"在当前仓库下，调整后正品库存为负数";
                                }
                            } else {
                                if (stockVO.getJunkQty().intValue()+Integer.parseInt(qty)<0){
                                    errorMsg = errorMsg + " 规格商家编码："+skuCode+"在当前仓库下，调整后次品库存为负数";
                                }
                            }
                        }

                    } else {
                        //批次，效期 场合下的处理 TODO
                    }
                }
                vo.setGoodsCode(goodsCode);
                vo.setGoodsName(goodsName);
                vo.setSkuCode(skuCode);
                vo.setSkuName(skuName);
                vo.setStockType(stockType);
                vo.setBatchCode(batchCode);
                vo.setProductDate(productDate);
                if (StringUtils.isNotBlank(qty)){
                    vo.setQty(Integer.valueOf(qty));
                }
                vo.setRemark(remark);
                listAdjustSkuVO.add(vo);
            }
            if (StringUtils.isNotBlank(errorMsg)){
                flg = false;
            }
            mapError.put("错误信息",errorMsg);
            mapError.put("规格商家编码",skuCode);
            mapError.put("库存类型",stockType);
            mapError.put("调整数",qty);
            mapError.put("批次编号",batchCode);
            mapError.put("生产日期",productDate);
            mapError.put("备注",remark);
            listError.add(mapError);
        }
        returnMap.put("json",listAdjustSkuVO);
        if (!flg) {
            returnMap.put("errorJson", listError);
        } else {
            returnMap.put("errorJson", null);
        }
        returnMap.put("result", "success");
        return returnMap;
    }
    
    public int getUnGoingCount(Map<String,String> paramMap) throws Exception{
        return adjustDAO.getUnGoingCount(paramMap);
    }

}
